home *** CD-ROM | disk | FTP | other *** search
/ Atari Forever 4 / Atari Forever 4.zip / Atari Forever 4.iso / PD_THEMA / EDITOREN / 7UP_PD / EDITOR4.C < prev    next >
C/C++ Source or Header  |  1998-03-14  |  44KB  |  1,715 lines
  1. /* Texteingabe */
  2. /*****************************************************************************
  3. *
  4. *                                              7UP
  5. *                                        Modul: EDITOR.C
  6. *                                     (c) by TheoSoft '90
  7. *
  8. *****************************************************************************/
  9. #include <portab.h>
  10. #include <stdio.h>
  11. #include <stdlib.h>
  12. #include <string.h>
  13. #include <ctype.h>
  14. #include <aes.h>
  15. #include <vdi.h>
  16.  
  17. #if GEMDOS
  18. #include <tos.h>
  19. #include <ext.h>
  20. #else
  21. #include <alloc.h>
  22. #include <dir.h>
  23. #endif
  24.  
  25. #include "alert.h"
  26. #include "7up.h"
  27. #include "forms.h"
  28. #include "windows.h"
  29.  
  30. #include "undo.h"
  31.  
  32. #include "language.h"
  33.  
  34. void mark_line(WINDOW *wp, LINESTRUCT *str, int line);
  35. LINESTRUCT *beg_blk(WINDOW *wp, LINESTRUCT *cutbeg, LINESTRUCT *cutend);
  36. LINESTRUCT *end_blk(WINDOW *wp, LINESTRUCT **cutbeg, LINESTRUCT **cutend);
  37. int cut_blk(WINDOW *wp, LINESTRUCT *cutbeg, LINESTRUCT *cutend);
  38. int copy_blk(WINDOW *wp, LINESTRUCT *cutbeg, LINESTRUCT *cutend, LINESTRUCT **copybeg, LINESTRUCT **copyend);
  39. void paste_blk(WINDOW *wp,LINESTRUCT *beg,LINESTRUCT *end);
  40. int ins_char(WINDOW *wp,LINESTRUCT *line, int c); /* neues zeichen einfügen */
  41. int ins_line(WINDOW *wp);                                  /* neue zeile einfügen */
  42. int backspace(WINDOW *wp,LINESTRUCT *line);          /* zeichen löschen */
  43. int del_char(WINDOW *wp,LINESTRUCT *line);            /* zeichen löschen */
  44. int del_line(WINDOW *wp);                                  /* zeile löschen */
  45. int cat_line(WINDOW *wp);                                  /* zeilen verbinden */
  46. void hide_blk(WINDOW *wp,LINESTRUCT *beg,LINESTRUCT *end);
  47. void free_blk(WINDOW *wp,LINESTRUCT *line);
  48. void shlf_line(WINDOW *wp, LINESTRUCT *begcut,  LINESTRUCT *endcut);
  49. void shrt_line(WINDOW *wp, LINESTRUCT *begcut,  LINESTRUCT *endcut);
  50. int adjust_best_position(WINDOW *wp);
  51. refresh(WINDOW *wp, LINESTRUCT *line, int col, int row);
  52.  
  53. extern OBJECT *winmenu,*desktop;
  54. extern int vdihandle,xdesk,ydesk,wdesk,hdesk;
  55. extern int cut, clipbrd,umlautwandlung,tabbar,scaktiv;
  56. extern int eszet,tabexp;
  57. extern char alertstr[256];
  58.  
  59. #define CR 0x0D /* dürfen nicht verwendet werden */
  60. #define LF 0x0A
  61. #define VERTICAL    1
  62. #define HORIZONTAL 2
  63. #define DEZTAB '#'
  64.  
  65. LINESTRUCT *lastwstr;
  66. long          lasthfirst,begline,endline;
  67. static WINDOW *copywindow;
  68. /*
  69. long *ckbd = NULL; /*Compose Keyboard von Pascal Fellerich*/
  70. */
  71.  
  72. void mark_line(WINDOW *wp, LINESTRUCT *str, int line)
  73. {                                                                  /* zeile markieren */
  74.     register int pxyarray[4],area[4],full[4],clip[4];
  75.  
  76.     clip[0]=wp->xwork - wp->wfirst + str->begcol*wp->wscroll;
  77.     clip[1]=wp->ywork + line * wp->hscroll;
  78.     clip[2]=(str->endcol-str->begcol)*wp->wscroll;
  79.     clip[3]=wp->hscroll;
  80.  
  81. #if MiNT
  82.    wind_update(BEG_UPDATE);
  83. #endif
  84.     _wind_get(0, WF_WORKXYWH, &full[0], &full[1], &full[2], &full[3]);
  85.     _wind_get(wp->wihandle, WF_FIRSTXYWH, &area[0], &area[1], &area[2], &area[3]);
  86.     while( area[2] && area[3] )
  87.     {
  88.         if(rc_intersect(full,area))
  89.         {
  90.             if(rc_intersect(clip,area))
  91.             {
  92.                 pxyarray[0]=area[0];
  93.                 pxyarray[1]=area[1];
  94.                 pxyarray[2]=area[0]+area[2]-1;
  95.                 pxyarray[3]=area[1]+area[3]-1;
  96.                 vs_clip(vdihandle,TRUE,pxyarray);
  97.                 vr_recfl(vdihandle,pxyarray);        /* schwarz markieren */
  98.             }
  99.         }
  100.         _wind_get(wp->wihandle, WF_NEXTXYWH, &area[0], &area[1], &area[2], &area[3]);
  101.     }
  102.     vs_clip(vdihandle,FALSE,pxyarray);
  103. #if MiNT
  104.    wind_update(END_UPDATE);
  105. #endif
  106. }
  107.  
  108. refresh(register WINDOW *wp, LINESTRUCT *line, register int col, register int row)
  109. {
  110.     register int area[4];
  111.  
  112.     area[0]=wp->xwork + col * wp->wscroll;
  113.     area[1]=wp->ywork + row * wp->hscroll;
  114.     area[2]=wp->wwork - col * wp->wscroll;
  115.     area[3]=wp->hscroll;
  116.     Wredraw(wp,area);
  117. }
  118.  
  119. int ins_char(WINDOW *wp, register LINESTRUCT *line, int c) /* zeichen einfügen */
  120. {
  121.     register long abscol;
  122.     char *help;
  123.     if(line->used < STRING_LENGTH)
  124.     {
  125.         abscol=wp->col+wp->wfirst/wp->wscroll; /* absolute position */
  126.         if(abscol<=line->used)                      /* höchstens zeilenende */
  127.         {
  128.             if(!(line->used < line->len))
  129.             {
  130.                 if((line->len += NBLOCKS) > STRING_LENGTH)
  131.                     line->len = STRING_LENGTH;
  132.                 help=realloc(line->string, line->len +1);
  133.                 if(help!=NULL)
  134.                     line->string=help;
  135.                 else
  136.                 {
  137.                     return(FALSE);
  138.                 }
  139.                 line->string[line->used]=0;
  140.             }
  141.             if(wp->w_state & INSERT)                                    /* einfügen */
  142.             {
  143.                 /* vom zeichen unter cursor rest nach rechts verschieben, insertmodus */
  144.                 memmove(&line->string[abscol+1],
  145.                          &line->string[abscol],
  146.                          strlen(&line->string[abscol]) +1);
  147.  
  148.                 line->string[abscol]=c;              /* zeichen setzen */
  149.                 line->used++;                            /* länge ändern */
  150.                 line->string[line->used]=0;         /* ende setzen */
  151.             }
  152.             else                                            /* überschreiben */
  153.             {
  154.                 line->string[abscol]=c;              /* zeichen setzen */
  155.                 if(abscol==line->used)
  156.                 {
  157.                     line->used++;
  158.                     line->string[line->used]=0;     /* ende setzen */
  159.                 }
  160.             }
  161.             return(TRUE);
  162.         }
  163.     }
  164.     return(FALSE);
  165. }
  166.  
  167. int ins_dezimal(WINDOW *wp, register LINESTRUCT *line, int c) /* zeichen einfügen */
  168. {
  169.     register long abscol;
  170.     register int i;
  171.     
  172.     if(line->used < STRING_LENGTH)
  173.     {
  174.         abscol=wp->col+wp->wfirst/wp->wscroll; /* absolute position */
  175.         if(abscol<=line->used)                      /* höchstens zeilenende */
  176.         {
  177.             for(i=abscol-1; i>=0; i--)
  178.                 if(line->string[i] == ' ')
  179.                 {
  180.                     memmove(&line->string[i],&line->string[i+1],abscol-i-1);
  181.                     line->string[abscol-1]=c;
  182.                     return(TRUE);
  183.                 }
  184.         }
  185.     }
  186.     return(FALSE);
  187. }
  188.  
  189. int can_ins_dezimal(WINDOW *wp, register LINESTRUCT *line) /* prüfen ob num-zeichen eingefügt werden kann */
  190. {
  191.     register long abscol;
  192.     register int i;
  193.     
  194.     if(line->used < STRING_LENGTH)
  195.     {
  196.         abscol=wp->col+wp->wfirst/wp->wscroll; /* absolute position */
  197.         if(abscol<=line->used)                      /* höchstens zeilenende */
  198.         {
  199.             for(i=abscol-1; i>=0; i--)
  200.                 if(line->string[i] == ' ')
  201.                     return(TRUE);
  202.         }
  203.     }
  204.     return(FALSE);
  205. }
  206.  
  207. int ins_line(WINDOW *wp)            /* neue zeile einfügen */
  208. {
  209.     register LINESTRUCT *insline;
  210.     register long abscol;
  211.     char *help;
  212.  
  213.     if((insline=malloc(sizeof(LINESTRUCT)))==NULL) /* insert */
  214.         return(FALSE);
  215.     insline->prev=0L;
  216.     insline->next=0L;
  217.     if((insline->string=(char *)malloc(NBLOCKS+1))==NULL)
  218.     {
  219.         free(insline);
  220.         return(FALSE);
  221.     }
  222.     insline->string[0]=0;
  223.     insline->used=0;
  224.     insline->len=NBLOCKS;
  225.     insline->attr=0;
  226.     insline->effect=TXT_NORMAL;
  227.  
  228.     if(wp->cstr) /* normale arbeitsweise */
  229.     {
  230.         abscol=wp->col+wp->wfirst/wp->wscroll; /* absolute position */
  231.         if(wp->cstr->next)
  232.         {
  233.             insline->next=wp->cstr->next; /* ersten hinten verknüpfen */
  234.             wp->cstr->next->prev=insline;
  235.         }
  236.         wp->cstr->next=insline;             /* dann vorne */
  237.         insline->prev=wp->cstr;
  238.         if(abscol < wp->cstr->used)
  239.         {
  240.             help=realloc(insline->string,strlen(&wp->cstr->string[abscol])+1);
  241.             if(help != NULL)
  242.                 insline->string=help;
  243.             else
  244.             {
  245.                 form_alert(1,Aeditor[0]);
  246.                 _exit(-1); /* ohne atexit Vektor */
  247.             }
  248.             strcpy(insline->string,&wp->cstr->string[abscol]);
  249.             insline->used=insline->len=strlen(insline->string);
  250.             wp->cstr->string[abscol]=0;
  251.             wp->cstr->used=strlen(wp->cstr->string);
  252.             refresh(wp,wp->cstr,wp->col,wp->row);
  253.         }
  254.         wp->col=0;
  255.         wp->cstr=insline;
  256.     }
  257.     else /* anfang des textes erzeugen */
  258.     {
  259.         wp->cstr=wp->wstr=wp->fstr=insline;
  260.     }
  261.     wp->hsize+=wp->hscroll;
  262.     return(TRUE);
  263. }
  264.  
  265. int cat_line(WINDOW *wp)
  266. {
  267.     register int i,diff;
  268.     register char save;
  269.     register long hfirst;
  270.     register LINESTRUCT *help;
  271.     char *temp;
  272.  
  273.     if(wp->cstr->prev)
  274.     {
  275.         if(wp->cstr->prev->used==0)
  276.         {
  277.             if(wp->cstr==wp->wstr) /* falls erste Zeile im Fenster */
  278.             {
  279. /* Koos Kuil 26.04.93 */
  280.                 if(Warrow(wp,WA_UPLINE))
  281.                 {
  282. /* 
  283.                     wp->cstr=wp->cstr->next;
  284.                     wp->row=1;
  285. */
  286.                 }
  287.             }
  288.             wp->cstr=wp->cstr->prev;      /* einfach vorherige zeile löschen */
  289.             wp->col=0;
  290.             wp->row--;
  291.             hfirst=wp->hfirst;                          /* letzte position merken */
  292.             del_line(wp);
  293.             if(wp->hfirst!=hfirst)                  /* wurde anfang zurückversetzt */
  294.             {
  295.                 if(wp->cstr->next)
  296.                 {
  297.                     wp->cstr=wp->cstr->next;    /* kann cursor versetzt werden */
  298.                     wp->row++;
  299.                 }
  300.             }
  301.             return(0);
  302.         }
  303.         else
  304.         {
  305.             if(wp->cstr==wp->wstr) /* falls erste Zeile im Fenster */
  306.             {
  307. /* Koos Kuil 26.04.93 */
  308.                 if(Warrow(wp,WA_UPLINE))
  309.                 {
  310. /*
  311.                     wp->cstr=wp->cstr->next;
  312.                     wp->row=1;
  313. */
  314.                 }
  315.             }
  316.             if(wp->cstr->used > 0) /* umkopieren */
  317.             {
  318.                 if((temp=realloc(wp->cstr->prev->string,wp->cstr->prev->used+wp->cstr->used+1))==NULL)
  319.                     return(FALSE);
  320.  
  321.                 wp->cstr->prev->string=temp;
  322.  
  323.                 diff = STRING_LENGTH - wp->cstr->prev->used;
  324.                 wp->col = wp->cstr->prev->used; /* cursor in die spalte hinter zeile */
  325.                 wp->row--;
  326.                 if(wp->cstr->used > diff)
  327.                 {
  328.                     save=wp->cstr->string[diff];
  329.                     wp->cstr->string[diff]=0;
  330.                 }
  331.                 strcat(wp->cstr->prev->string,wp->cstr->string);
  332.                 wp->cstr->prev->len=wp->cstr->prev->used=
  333.                     strlen(wp->cstr->prev->string);
  334.                 if(wp->cstr->used > diff)
  335.                 {
  336.                     wp->cstr->string[diff]=save;
  337.                 }
  338.                 wp->cstr=wp->cstr->prev;
  339.                 refresh(wp, wp->cstr,wp->col,wp->row);
  340.                 wp->cstr=wp->cstr->next;
  341.                 wp->row++;
  342.                 if(wp->cstr->used > diff)
  343.                 {
  344.                     strcpy(wp->cstr->string,&wp->cstr->string[diff]);
  345.                     wp->cstr->used=strlen(wp->cstr->string);
  346.                     refresh(wp, wp->cstr, 0, wp->row );
  347.                     wp->cstr=wp->cstr->prev;
  348.                 }
  349.                 else
  350.                 {
  351.                     hfirst=wp->hfirst;                      /* letzte position merken */
  352.                     temp=wp->cstr->next;
  353.                     del_line(wp);
  354.                     if(wp->hfirst==hfirst)          /* wurde anfang zurückversetzt */
  355.                     {
  356.                         if(wp->cstr->prev && wp->cstr==temp)
  357.                         {
  358.                             wp->cstr=wp->cstr->prev;    /* kann cursor versetzt werden */
  359.                             wp->row--;
  360.                         }
  361.                     }
  362.                 }
  363.             }
  364.             else
  365.             {
  366.                 hfirst=wp->hfirst;                      /* letzte position merken */
  367.                 temp=wp->cstr->next;
  368.                 del_line(wp);
  369.                 wp->col=wp->cstr->used;
  370.                 if(wp->hfirst==hfirst)          /* wurde anfang zurückversetzt */
  371.                 {
  372.                     if(wp->cstr->prev && wp->cstr==temp)
  373.                     {
  374.                         wp->cstr=wp->cstr->prev;    /* kann cursor versetzt werden */
  375.                         wp->col=wp->cstr->used;
  376.                         wp->row--;
  377.                     }
  378.                 }
  379.             }
  380.             if(wp->col > wp->wwork/wp->wscroll-1)
  381.             {
  382.                 i=wp->col/(wp->wwork/wp->wscroll);
  383.                 wp->col -= i*wp->wwork/wp->wscroll;
  384.                 while(i--)
  385.                     Warrow(wp,WA_RTPAGE);
  386.             }
  387.         }
  388.     }
  389.     return(FALSE);
  390. }
  391.  
  392. int backspace(WINDOW *wp, register LINESTRUCT *line)
  393. {                                             /* zeichen links vom cursor löschen */
  394.     register long abscol;
  395.  
  396.     abscol=wp->col+wp->wfirst/wp->wscroll - 1; /* zeichen vor dem cursor, absolute position */
  397.  
  398.     /* vom zeichen unter cursor ein zeichen nach links schieben, zeichen...*/
  399.     /* ... wird dabei automatisch gelöscht */
  400.     strcpy(&line->string[abscol],&line->string[abscol+1]);
  401.     line->used--;                              /* länge kürzen */
  402.     return(TRUE);
  403. }
  404.  
  405. int del_char(WINDOW *wp, register LINESTRUCT *line)
  406. {                                                      /* zeichen unter cursor löschen */
  407.     register long abscol;
  408.     GRECT rect;
  409.  
  410.     abscol=wp->col+wp->wfirst/wp->wscroll; /* zeichen vor dem cursor, absolute position */
  411.     if(!abscol && !line->used)
  412.     {
  413.         del_line(wp);
  414.         return(TRUE); /* FALSE */
  415.     }
  416.     if(abscol < line->used)
  417.     {
  418.         strcpy(&line->string[abscol],&line->string[abscol+1]);
  419.         line->used--;                              /* länge kürzen */
  420.         rect.g_x=wp->xwork + wp->col * wp->wscroll;
  421.         rect.g_y=wp->ywork + wp->row * wp->hscroll;
  422.         rect.g_w=wp->wwork - wp->col * wp->wscroll;
  423.         rect.g_h=wp->hscroll;
  424.         Wscroll(wp,HORIZONTAL,wp->wscroll,&rect);
  425.         return(TRUE); /* FALSE */
  426.     }
  427.     else
  428.         return(FALSE);
  429. }
  430.  
  431. int del_line(WINDOW *wp)
  432. {
  433.     LINESTRUCT *begcut, *endcut;
  434.     int savecol;
  435.  
  436.     if(! wp->cstr->prev && !wp->cstr->next) /* erste und einzige zeile */
  437.     {
  438.         wp->cstr->string[0]=0;
  439.         wp->cstr->used=0;
  440.         refresh(wp,wp->cstr,0,wp->row);
  441.     }
  442.     else
  443.     {
  444.         lastwstr=wp->wstr;
  445.         lasthfirst=wp->hfirst;
  446.         begcut=endcut=wp->cstr;     /* anfang = ende */
  447.         begline=wp->row+wp->hfirst/wp->hscroll;  /* zeilen = 1 */
  448.         endline=begline+1;
  449.         begcut->begcol=endcut->begcol=0;
  450.         begcut->endcol=endcut->endcol=STRING_LENGTH;
  451.  
  452.         savecol=wp->col;
  453.         cut=cut_blk(wp, begcut, endcut);      /* cuten */
  454.         free_blk(wp,begcut);                     /* hwds! */
  455.         wp->col=savecol;
  456.     }
  457.     return(FALSE);
  458. }
  459.  
  460. int del_eoln(WINDOW *wp)
  461. {
  462.     wp->cstr->string[wp->col+wp->wfirst/wp->wscroll]=0;
  463.     wp->cstr->used=strlen(wp->cstr->string);
  464.     refresh(wp, wp->cstr, wp->col, wp->row);
  465. }
  466.  
  467. int adjust_best_position(WINDOW *wp) /* evtl. unten anpassen */
  468. {
  469.     register int i,fline,lline;
  470.     if(wp->hfirst!=0 && wp->hfirst + wp->hwork > wp->hsize)
  471.     {
  472.         lline=wp->hfirst/wp->hscroll;     /* erste zeile merken */
  473.         wp->hfirst = wp->hsize-wp->hwork; /* neu setzen */
  474.         if(wp->hfirst<0)
  475.             wp->hfirst=0;
  476.         fline=wp->hfirst/wp->hscroll;      /* neue erste zeile */
  477.         if(fline<lline)  /* kann nur kleiner sein, weil zurückpositioniert */
  478.             for(i=fline; i<lline; i++)     /* zeiger zurück setzen */
  479.             {
  480.                 wp->wstr=wp->wstr->prev;    /* window und cursor */
  481.             }
  482.         return(TRUE);
  483.     }
  484.     return(FALSE);
  485. }
  486.  
  487. int hndl_umbruch(OBJECT *tree, WINDOW *wp, int start)
  488. {
  489.    int umbruch=0;
  490.     if(wp)
  491.     {
  492.         sprintf(tree[UMBRUCH].ob_spec.tedinfo->te_ptext,"%d",wp->umbruch-1);
  493.         if(form_exhndl(tree,0,0)==UMBRABBR)
  494.             return(wp->umbruch);
  495.         umbruch=atoi(form_read(tree,UMBRUCH,alertstr))+1;
  496.         if(umbruch<2)
  497.             umbruch=2;
  498.         if(umbruch>STRING_LENGTH)
  499.             umbruch=STRING_LENGTH;
  500.     }
  501.     return(umbruch);
  502. }
  503.  
  504. void blockformat(char *str, int diff) /* mit blanks expandieren */
  505. {
  506.     register int i,k,endlos=TRUE;
  507.  
  508.     if(diff<0)
  509.         return;
  510.  
  511.     k=strlen(str);
  512.     do
  513.     {
  514.         for(i=0; i<k; i++) /* führende Blanks überspringen */
  515.             if(str[i]!=' ')
  516.                 break;
  517.         for(i; i<k && diff; i++)
  518.         {
  519.             if(str[i]==' ' /*|| str[i]=='\t'*/)
  520.             {
  521.                 memmove(&str[i+1],&str[i],strlen(&str[i])+1);
  522.                 str[i]=' ';
  523.                 i+=2;
  524.                 k++;
  525.                 diff--;
  526.                 endlos=FALSE;
  527.             }
  528.         }
  529.         if(endlos)
  530.           break;
  531.     }
  532.     while(diff>0 && !endlos);
  533. }
  534.  
  535. int findlastspace(char *str, int umbr, int abs)
  536. {
  537.     int saveabs;
  538.     saveabs = abs;
  539.     
  540.     while(abs >= umbr) /* zurück zum Umbruch */
  541.         abs--;
  542.     while(str[abs] != ' ' && str[abs]!='\t' && abs>0)
  543.         abs--;
  544.     if(abs==0)
  545.     {
  546.         while(saveabs > umbr) /* zurück zum Umbruch */
  547.         {
  548.             if(str[saveabs] == ' ')
  549.                 return(saveabs);
  550.             else
  551.                 saveabs--;
  552.         }
  553.     }
  554.     return(abs/*?abs:umbr*/); /* 10.7.94 */
  555. }
  556.  
  557. int ispossible(LINESTRUCT *line)  /* beim zweiten RETURN kein Einrücken */
  558. {
  559.     int i;
  560.     if(line)
  561.     {
  562.         for(i=0; i<line->used; i++)
  563.             if(line->string[i]!=' ')
  564.                 return(TRUE);
  565.         return(FALSE);
  566.     }
  567.     return(TRUE);
  568. }
  569.  
  570. int isgerman(char key)
  571. {
  572.     char *cp;
  573.     static char german[]=
  574.     {
  575.         'ä','Ä','ö','Ö','ü','Ü','ß','β','_',0
  576.     };
  577.     cp=german;
  578.     do
  579.     {
  580.         if(key == *cp)
  581.             return(TRUE);
  582.     }
  583.     while(*++cp);
  584.     return(FALSE);
  585. }
  586.  
  587. static int _editor(register WINDOW *wp, int state, int key, LINESTRUCT **begcut, LINESTRUCT **endcut)
  588. {
  589.     Wcursor(wp);
  590.     editor(wp,state,key,begcut,endcut);
  591.     graf_mouse(M_OFF,NULL);
  592.     Wcursor(wp);
  593. }
  594.  
  595. int editor(register WINDOW *wp, int state, int key, LINESTRUCT **begcut, LINESTRUCT **endcut) /* zeicheneingabe auswerten */
  596. {
  597.     register int abscol,i,y,nexttab,prevtab;
  598.     int clip[4],errcode=0,col,block=FALSE;
  599.     GRECT rect;
  600.     char *cp,outchar[2]=" ";
  601.  
  602.     static int dk[2]={0,0};
  603.  
  604.     if(wp)
  605.     {
  606.         /* markierten Block gleich ersetzen. Sichern in UNDOpuffer */
  607.         if((char)key != 0x1B)    /* != ESC */
  608.         {    
  609.           /* aktuelle Zeile für Zeilenundo sichern */
  610.             if((undo.cp  != wp->cstr->string) &&
  611.                 (undo.row != wp->hfirst/wp->hscroll+wp->row)) /* für undo string retten */
  612.             {    /* auch row merken, weil sich beim einfügen adresse ändert */
  613.                 strcpy(undo.string,wp->cstr->string);
  614.                 undo.cp =wp->cstr->string;
  615.                 undo.col=wp->col;
  616.                 undo.row=wp->row+wp->hfirst/wp->hscroll;
  617.             }
  618.             if(!cut && (*begcut) && (*endcut)) /* markierten Block löschen */
  619.             {
  620.             if((*begcut)==wp->fstr && (*endcut)->next==NULL)
  621.             {
  622.                if(form_alert(2,Aeditor[6])==1)
  623.                   return;
  624.             }
  625.                  if((*begcut) == (*endcut))
  626.                  {
  627.                     if(endline != begline) /* ganze Zeile */
  628.                       undo.item=LINEPAST;
  629.                     else
  630.                        undo.item=LINEUNDO;
  631.                  }
  632.                  else
  633.                     undo.item=LINEPAST;
  634.                 hndl_blkfind(wp,(*begcut),(*endcut),SEARBEG);
  635.                 graf_mouse(M_OFF,0L);
  636.                 Wcursor(wp);
  637.                free_undoblk(wp,undo.blkbeg); /* Block weg */
  638.                 if((wp->w_state&COLUMN))
  639.                 {
  640.                     cut=cut_col(wp,(*begcut),(*endcut));
  641.                undo.flag=copy_col(wp,(*begcut),(*endcut),&undo.blkbeg,&undo.blkend);
  642.                 }
  643.                 else
  644.                 {
  645.                     cut=cut_blk(wp,(*begcut),(*endcut));
  646.                undo.flag=copy_blk(wp,(*begcut),(*endcut),&undo.blkbeg,&undo.blkend);
  647.                 }
  648.                 Wcuron(wp);
  649.                 Wcursor(wp);
  650. /*
  651.                 graf_mouse(M_ON,0L);
  652. */
  653.                free_blk(wp,(*begcut)); /* Block weg */
  654.                if(undo.item==LINEPAST)
  655.                {
  656.                    strcpy(undo.string,wp->cstr->string); /* nochmal für LINEPASTE */
  657.                    undo.cp =wp->cstr->string;
  658.                    undo.col=wp->col;
  659.                    undo.row=wp->row+wp->hfirst/wp->hscroll;
  660.                 }
  661.                 block=TRUE;
  662.             }
  663.       }
  664.         if(!(state & (K_CTRL|K_ALT)) && !(key & 0x8000))/* keine sondertaste (control) */
  665.         {
  666.             graf_mouse(M_OFF,0L);
  667.             Wcursor(wp);
  668.             wp->cspos=Wshiftpage(wp,0,wp->cstr->used);
  669.             switch(key)
  670.             {
  671.                 case 0x0009:    /*  tab  */
  672.                     wp->w_state|=CHANGED; /* es wurde editiert */
  673.                     if(!tabexp)
  674.                         goto INS_CHAR;
  675.                     if(!block)
  676.                     {
  677.                         undo.item=LINEUNDO;
  678.                         if(tabbar)
  679.                         {
  680.                             nexttab=Wgetnexttab(wp);
  681.                         }
  682.                         else
  683.                         {
  684.                             nexttab=wp->tab-(wp->col%wp->tab);
  685.                             nexttab=(nexttab ? nexttab : wp->tab);
  686.                         }
  687.                         if(wp->w_state & INSERT)
  688.                         {
  689.                             for(i=0; i<nexttab; i++)
  690.                             {
  691.                                 if(ins_char(wp,wp->cstr,' '))
  692.                                 {
  693.                                     refresh(wp, wp->cstr, wp->col , wp->row);
  694.                                     if(++wp->col > wp->wwork/wp->wscroll-1) /* scrollen */
  695.                                     {
  696.                                         wp->col--;
  697.                                         if(Warrow(wp,WA_RTLINE))
  698.                                             wp->col++;      /*-=4;*/
  699.                                     }
  700.                                 }
  701.                             }
  702.                         }
  703.                         else
  704.                         {
  705.                             if((wp->col+=nexttab) > wp->wwork/wp->wscroll-1) /* scrollen */
  706.                             {
  707.                                 wp->col-=nexttab;
  708.                                 if(Warrow(wp,WA_RTLINE))
  709.                                     wp->col;/*++*/  /*-=4;*/
  710.                             }
  711.                         }
  712.                     }
  713.                     break;
  714.                 case 0x0209:    /*  shift tab : eigentlich quatsch */
  715.                     if(tabbar)
  716.                     {
  717.                         prevtab=Wgetprevtab(wp, wp->toolbar);
  718.                     }
  719.                     else
  720.                     {
  721.                         prevtab=wp->col%wp->tab;
  722.                         prevtab=(prevtab ? prevtab : wp->tab);
  723.                     }
  724.                     wp->col-=prevtab;
  725.                     break;
  726.                 case 0x000D: /* RETURN */
  727.                 case 0x020D: /* S " */
  728.                 case 0x400D: /* ENTER auf Zehnerblock */
  729.                 case 0x420D: /* S " */
  730.                     undo.item=FALSE;
  731.                     if((wp->w_state & INSERT) || !wp->cstr->next)
  732.                     {
  733.                         if(ins_line(wp))
  734.                         {
  735.                             wp->w_state|=CHANGED; /* es wurde editiert */
  736.                             if(++wp->row > wp->hwork/wp->hscroll-1 )/* scrollen */
  737.                             {
  738.                                 refresh(wp,wp->cstr,0,wp->row);
  739.                                 Warrow(wp,WA_DNLINE);
  740.                                 Wslide(wp,0,HSLIDE);
  741.                                 wp->col=0;
  742.                             }
  743.                             else
  744.                             {
  745.                                 rect.g_x=wp->xwork;
  746.                                 rect.g_y=wp->ywork + (wp->row) * wp->hscroll;
  747.                                 rect.g_w=wp->wwork;
  748.                                 rect.g_h=wp->hwork - (wp->row) * wp->hscroll;
  749.                                 Wscroll(wp,VERTICAL,-wp->hscroll,&rect);
  750.                                 Wslide(wp,0,HSLIDE);
  751.                                 wp->col=0;
  752.                             }
  753.                             if((wp->w_state & INDENT) && ispossible(wp->cstr->prev)) /* cursor einrücken, auto-indent */
  754.                             {
  755.                                 for(i=0; i<wp->cstr->prev->used && wp->cstr->prev->string[i] == ' '; i++)
  756.                                     if(ins_char(wp,wp->cstr,' '))
  757.                                     {
  758.                                         wp->col++;
  759.                                     }
  760.                                 refresh(wp, wp->cstr, 0, wp->row);
  761.                                 if(wp->col==0) /* nicht eingerückt */
  762.                                   undo.item=BACKSPACE;
  763.                             }
  764.                         }
  765.                     }
  766.                     else
  767.                     {
  768.                         wp->col=0;
  769.                         if(wp->cstr->next)
  770.                         {
  771.                             if(++wp->row > wp->hwork/wp->hscroll-1 )/* scrollen */
  772.                             {
  773.                                 Warrow(wp,WA_DNLINE);
  774.                             }
  775.                             else
  776.                                 wp->cstr=wp->cstr->next; /* Cursor vor     */
  777.                         }
  778.                     }
  779.                     undo.cp=NULL; /* löschen, weil sonst fehlerhaft */
  780.                     undo.row=-1;
  781.                     break;
  782.                 case 0x007F: /* DELETE */
  783.                     wp->w_state|=CHANGED; /* es wurde editiert */
  784.                     if(!block)
  785.                     {
  786.                         undo.item=LINEUNDO;
  787.                         if(!del_char(wp,wp->cstr))
  788.                             if(wp->cstr->next)
  789.                             {
  790.                                 undo.item=FALSE;
  791.                                 wp->cstr=wp->cstr->next;
  792.                                 wp->col=0;
  793.                                 wp->row++;
  794.                                 cat_line(wp);
  795.                                 undo.item=RETURN;
  796.                             }
  797.                     }
  798.                     break;
  799.                 case 0x0008: /* BACKSPACE */
  800.                 case 0x0208: /* S " */
  801.                     wp->w_state|=CHANGED; /* es wurde editiert */
  802.                     if(!block)
  803.                     {
  804.                         if(!(wp->wfirst == 0 && wp->col == 0))
  805.                         {
  806.                             undo.item=LINEUNDO;
  807.                             backspace(wp,wp->cstr);
  808.                             wp->col--;
  809.                             rect.g_x=wp->xwork + wp->col * wp->wscroll;
  810.                             rect.g_y=wp->ywork + wp->row * wp->hscroll;
  811.                             rect.g_w=wp->wwork - wp->col * wp->wscroll;
  812.                             rect.g_h=wp->hscroll;
  813.                             Wscroll(wp,HORIZONTAL,wp->wscroll,&rect);
  814.                         }
  815.                         else
  816.                         {
  817.                             undo.item=RETURN;
  818.                             cat_line(wp);
  819.                         }
  820.                     }
  821.                     break;
  822.                 case 0x001B: /* ESC */
  823. /*
  824.                     if(ckbd) /*CKBD geladen, überlassen wirs diesem Treiber*/
  825.                         goto DEADKEY;
  826. */
  827.                     if (!scaktiv) /* Shortcuts nicht aktiv */
  828.                         goto NODEADKEY;
  829.                         
  830.                     if(dk[0]!=0x1B)
  831.                         dk[0]=0x1B;
  832.                     else
  833.                         dk[0]=0;
  834.                     break;
  835.                     
  836. /* GEMDOS */default:
  837. INS_CHAR:
  838.                     key=(char)key;
  839. /*
  840.                     if(ckbd) /*CKBD geladen, überlassen wirs diesem Treiber*/
  841.                         goto DEADKEY;
  842. */
  843.                     if (!scaktiv)  /* Shortcuts nicht aktiv */
  844.                         goto NODEADKEY;
  845.                         
  846.                     if(dk[0]==0x1B) /* ESC = deadkey */
  847.                     {
  848.                         if(!dk[1])
  849.                         {
  850.                             dk[1]=isdeadkey(key);
  851.                             if(!dk[1])
  852.                             {
  853.                                 dk[0]=0;
  854.                                 goto NODEADKEY;
  855.                             }
  856.                         }
  857.                         else
  858.                         {
  859.                      cp=NULL;
  860.                             key=deadkey(dk[1],key,&cp);
  861.                             dk[0]=dk[1]=0;
  862.                             if(key) /* einzelnes Zeichen */
  863.                                goto NODEADKEY;
  864.                             if(cp)  /* Shortcutzeichenkette */
  865.                             {
  866.                         col=-1; /* zurücksetzen auf ungültig */
  867.                                 while((*cp!='\r') && (*cp!=0))
  868.                                 {
  869.                                     Wcursor(wp);
  870. /*
  871.                                     graf_mouse(M_ON,NULL);
  872. */
  873.                            if(*cp!='~')
  874.                                        editor(wp,0,(int)*cp,begcut,endcut);
  875.                                    else
  876.                                       col=wp->col;
  877.                                     graf_mouse(M_OFF,NULL);
  878.                                     Wcursor(wp);
  879.                                     cp++;
  880.                                 }
  881.                                 if(col>-1)    /* abfragen und setzen */
  882.                                    wp->col=col; /* Tilde in Shortcut */
  883.                              }
  884.                         }
  885.                     }
  886.                     else
  887.                     {
  888. NODEADKEY:
  889.                         if(!block)
  890.                             undo.item=LINEUNDO;
  891.                         if(key && key!=CR && key!=LF)
  892.                         {
  893.                             wp->w_state|=CHANGED; /* es wurde editiert  */
  894.                             if(umlautwandlung)    /* TeX-Umlautwandlung */
  895.                             {
  896.                                 switch(key)
  897.                                 {
  898.                                     case 'ä':
  899.                                         _editor(wp,0,'"',begcut,endcut);
  900.                                         _editor(wp,0,'a',begcut,endcut);
  901.                                         goto ENDE;
  902.                                         break;
  903.                                     case 'Ä':
  904.                                         _editor(wp,0,'"',begcut,endcut);
  905.                                         _editor(wp,0,'A',begcut,endcut);
  906.                                         goto ENDE;
  907.                                         break;
  908.                                     case 'ö':
  909.                                         _editor(wp,0,'"',begcut,endcut);
  910.                                         _editor(wp,0,'o',begcut,endcut);
  911.                                         goto ENDE;
  912.                                         break;
  913.                                     case 'Ö':
  914.                                         _editor(wp,0,'"',begcut,endcut);
  915.                                         _editor(wp,0,'O',begcut,endcut);
  916.                                         goto ENDE;
  917.                                         break;
  918.                                     case 'ü':
  919.                                         _editor(wp,0,'"',begcut,endcut);
  920.                                         _editor(wp,0,'u',begcut,endcut);
  921.                                         goto ENDE;
  922.                                         break;
  923.                                     case 'Ü':
  924.                                         _editor(wp,0,'"',begcut,endcut);
  925.                                         _editor(wp,0,'U',begcut,endcut);
  926.                                         goto ENDE;
  927.                                         break;
  928.                                     case 0x9E:    /*'ß'*/
  929.                                     case 0xE1:    /*'ß'*/
  930.                                         _editor(wp,0,'"',begcut,endcut);
  931.                                         _editor(wp,0,'s',begcut,endcut);
  932.                                         goto ENDE;
  933.                                         break;
  934. /*
  935.                                     case 'ä':
  936.                                         _editor(wp,0,'a',begcut,endcut);
  937.                                         _editor(wp,0,'e',begcut,endcut);
  938.                                         goto ENDE;
  939.                                         break;
  940.                                     case 'Ä':
  941.                                         _editor(wp,0,'A',begcut,endcut);
  942.                                         _editor(wp,0,'e',begcut,endcut);
  943.                                         goto ENDE;
  944.                                         break;
  945.                                     case 'ö':
  946.                                         _editor(wp,0,'o',begcut,endcut);
  947.                                         _editor(wp,0,'e',begcut,endcut);
  948.                                         goto ENDE;
  949.                                         break;
  950.                                     case 'Ö':
  951.                                         _editor(wp,0,'O',begcut,endcut);
  952.                                         _editor(wp,0,'e',begcut,endcut);
  953.                                         goto ENDE;
  954.                                         break;
  955.                                     case 'ü':
  956.                                         _editor(wp,0,'u',begcut,endcut);
  957.                                         _editor(wp,0,'e',begcut,endcut);
  958.                                         goto ENDE;
  959.                                         break;
  960.                                     case 'Ü':
  961.                                         _editor(wp,0,'U',begcut,endcut);
  962.                                         _editor(wp,0,'e',begcut,endcut);
  963.                                         goto ENDE;
  964.                                         break;
  965.                                     case 0x9E:    /*'ß'*/
  966.                                     case 0xE1:    /*'ß'*/
  967.                                         _editor(wp,0,'s',begcut,endcut);
  968.                                         _editor(wp,0,'s',begcut,endcut);
  969.                                         goto ENDE;
  970.                                         break;
  971. */
  972.                                 }
  973.                             }
  974.                             if(isnum(key) && (Wgettab(wp)==DEZTAB) && can_ins_dezimal(wp,wp->cstr))
  975.                             {
  976.                                 if(ins_dezimal(wp,wp->cstr,key))
  977.                                 {
  978.                                     rect.g_x=wp->xwork;
  979.                                     rect.g_y=wp->ywork + wp->row * wp->hscroll;
  980.                                     rect.g_w=wp->wwork;
  981.                                     rect.g_h=wp->hscroll;
  982.                                     Wredraw(wp,&rect);
  983.                                 }
  984.                             }
  985.                             else
  986.                             {
  987.                                 if(ins_char(wp,wp->cstr,key))
  988.                                 {
  989.                                     if((wp->w_state & INSERT) && (wp->col+wp->wfirst/wp->wscroll < wp->cstr->used-1))
  990.                                     {
  991.                                         rect.g_x=wp->xwork + wp->col * wp->wscroll;
  992.                                         rect.g_y=wp->ywork + wp->row * wp->hscroll;
  993.                                         rect.g_w=wp->wwork - wp->col * wp->wscroll;
  994.                                         rect.g_h=wp->hscroll;
  995.                                         Wscroll(wp,HORIZONTAL,-wp->wscroll,&rect);
  996.                                     }
  997.                                     else
  998.                                     {
  999.                                         rect.g_x=wp->xwork + wp->col * wp->wscroll;
  1000.                                         rect.g_y=wp->ywork + wp->row * wp->hscroll;
  1001.                                         rect.g_w=wp->wscroll;
  1002.                                         rect.g_h=wp->hscroll;
  1003.                                         Wredraw(wp,&rect);
  1004.                                     }
  1005.                                     wp->col++;
  1006.                                 }
  1007.                             }
  1008.                               col=abscol=wp->col+wp->wfirst/wp->wscroll;
  1009.                             if(abscol >= wp->umbruch)
  1010.                             {
  1011.                                 abscol=findlastspace(wp->cstr->string, wp->umbruch, abscol);
  1012.                                 if(abscol>0)
  1013.                                 {
  1014.                                     wp->cspos=wp->col=abscol-wp->wfirst/wp->wscroll+1;
  1015.                                     wp->cspos=Wshiftpage(wp,0,wp->cstr->used);
  1016.                                     Wcursor(wp);
  1017. /*
  1018.                                     graf_mouse(M_ON,NULL);
  1019. */
  1020.                                     editor(wp,0,0x000D,begcut,endcut);
  1021.                                     graf_mouse(M_OFF,NULL);
  1022.                                     Wcursor(wp);
  1023.  
  1024.                                     wp->col+=(col-abscol)-wp->wfirst/wp->wscroll-1;
  1025.  
  1026.                                     if(wp->w_state & BLOCKSATZ)
  1027.                                     {
  1028.                                         blockformat(wp->cstr->prev->string, wp->umbruch-wp->cstr->prev->used);
  1029.                                         wp->cstr->prev->used=strlen(wp->cstr->prev->string);
  1030.                                         refresh(wp, wp->cstr->prev, 0, wp->row-1);
  1031.                                     }
  1032.                                 }
  1033.                             }
  1034.                         }
  1035.                     }
  1036.                     break;
  1037.             }
  1038. ENDE:
  1039.             wp->cspos=Wshiftpage(wp,0,wp->cstr->used);
  1040.           Wcuron(wp);
  1041.             Wcursor(wp);
  1042. /*
  1043.             graf_mouse(M_ON,0L);
  1044. */
  1045.         }
  1046.     }
  1047.     return(errcode);
  1048. }
  1049.  
  1050. WINDOW *twp;
  1051. void hndl_chartable(WINDOW *wp, OBJECT *tree)
  1052. {
  1053.     int c,ret,kstate,ende;
  1054.     long dummy=0;
  1055.     
  1056.     if(wp)
  1057.     {
  1058.         ende = FALSE;
  1059.         twp=wp;
  1060.         form_exopen(tree,0);
  1061.         do
  1062.         {
  1063.             c=(form_exdo(tree,0)&0x7FFF);
  1064.             switch(c)
  1065.             {
  1066.                 case CHARHELP:
  1067.                     form_alert(1,Aeditor[5]);
  1068.                     objc_change(tree,c,0,tree->ob_x,tree->ob_y,
  1069.                         tree->ob_width,tree->ob_height,tree[c].ob_state&~SELECTED,TRUE);
  1070.                     break;
  1071.                 case CHAROK:
  1072.                     ende = TRUE;
  1073.                     break;
  1074.                 default:
  1075.                     graf_mkstate(&ret,&ret,&ret,&kstate);
  1076.                     if(kstate&(K_LSHIFT|K_RSHIFT))
  1077.                     {
  1078.                         sprintf(alertstr,Aeditor[1],
  1079.                             (c-FCHAR)&0xff,(c-FCHAR)&0xff,(c-FCHAR)&0xff);
  1080.                         if(form_alert(2,alertstr) == 2)
  1081.                         {
  1082.                             ende = TRUE;
  1083.                         }
  1084.                     }
  1085.                     else
  1086.                     {
  1087.                         ende = TRUE;
  1088.                     }
  1089.                     objc_change(tree,c,0,
  1090.                         tree->ob_x,tree->ob_y,tree->ob_width,tree->ob_height,
  1091.                         NORMAL,TRUE);
  1092.                     break;
  1093.             }
  1094.         }
  1095.         while(!ende);
  1096.         form_exclose(tree,c,FALSE);
  1097.         tree[FCHAR+256].ob_state&=~SELECTED;
  1098.  
  1099.         Wdefattr(wp);
  1100.  
  1101.         if(c>0 && c<(FCHAR+256))
  1102.             editor(wp,0,(c-FCHAR)&0xff,&dummy,&dummy);
  1103.     }
  1104. }
  1105.  
  1106. static MEVENT mevent=
  1107. {
  1108.     MU_TIMER|MU_KEYBD,
  1109.     2,1,1,
  1110.     0,0,0,0,0,
  1111.     0,0,0,0,0,
  1112.     NULL,
  1113.     0L,
  1114.     0,0,0,0,0,0,
  1115. /* nur der Vollständigkeit halber die Variablen von XGEM */
  1116.     0,0,0,0,0,
  1117.     0,
  1118.     0L,
  1119.     0L,0L
  1120. };
  1121.  
  1122. /* mit ALT-Taste Dezimalwert eingeben, nur GEMDOS */
  1123. int altnum(int *state, int *key)
  1124. {
  1125. #if GEMDOS
  1126.     char num[4];
  1127.     register int i=1,event;
  1128. /*
  1129.     if(ckbd) return(FALSE); /*Wenn Compose Keyboard geladen ist, raus.*/
  1130. */
  1131. /* geht auch dann nicht
  1132.     if(_GemParBlk.global[0]>=0x0400) /* Falcon TOS kanns selbst */
  1133.         return(FALSE);
  1134. */                         /* & geht nicht wg. Shift*/
  1135.     if((*state == K_ALT) && isdigit(*key))
  1136.     {  /*  1        2        3        4  */
  1137.         num[0]=num[1]=num[2]=num[3]=0;
  1138.         num[0]=(char)(*key);
  1139.       mevent.e_time=0;
  1140.         do
  1141.         {
  1142.              event=evnt_event(&mevent);
  1143.              if(event & MU_KEYBD)
  1144.              {
  1145.                  if(!isdigit(mevent.e_kr))
  1146.                      return(FALSE);
  1147.                  num[i++]=(char)mevent.e_kr;
  1148.              }
  1149.         }
  1150.         while(i<4 && (mevent.e_ks == K_ALT));
  1151.         if((i=atoi(num))>0)
  1152.         {
  1153.             *state=0;
  1154.             *key=i;
  1155.             return(TRUE);
  1156.         }
  1157.     }
  1158. #endif
  1159.     return(FALSE);
  1160. }
  1161.  
  1162. int special(WINDOW *wp, WINDOW **blkwp, int state, int key, LINESTRUCT **begcut, LINESTRUCT **endcut)
  1163. {
  1164.     LINESTRUCT *line;
  1165.     int ret=FALSE,i,mx,my,y,len,used,wordend;
  1166.     char *cp;
  1167.     unsigned char c;
  1168.     extern int exitcode;
  1169.     extern char errorstr[];
  1170.     extern OBJECT *markmenu,*divmenu;
  1171.     extern WINDOW _wind[];
  1172.    GRECT rect;
  1173.    
  1174.     if(wp) /* ab jetzt nur mit offenem Fenster */
  1175.     {
  1176.         if(!state)
  1177.         {
  1178.             switch(key)
  1179.             {
  1180.                 case 0x8052: /* INSERT */
  1181.                graf_mouse(M_OFF,NULL);
  1182.                Wcursor(wp);
  1183.                     Menu_icheck(winmenu,FORMINS,(wp->w_state^=INSERT)&INSERT?TRUE:FALSE);
  1184.                     Wcuron(wp);
  1185.                Wcursor(wp);
  1186. /*
  1187.                graf_mouse(M_ON,NULL);
  1188. */
  1189.                     return(TRUE);
  1190.                 case 0x8061: /* UNDO */
  1191.                     do_undo(wp);
  1192.                     return(TRUE);
  1193.                 case 0x8062: /* HELP */
  1194.                     if(!help())
  1195.                     {
  1196.                   sprintf(alertstr,Aeditor[2],(char *)(divmenu[DIVHDA].ob_spec.index/*+16L*/));
  1197.                         form_alert(1,alertstr);
  1198.                     }
  1199.                     return(TRUE);
  1200.             }
  1201.             return(FALSE);
  1202.         }
  1203.         if(state & (K_LSHIFT | K_RSHIFT))
  1204.         {
  1205.             switch(key)
  1206.             {
  1207.             case 0x8252: /* Shift Insert */
  1208.                return(TRUE);
  1209.                 case 0x8261: /* Shift Undo */
  1210.                     return(TRUE);
  1211.                 case 0x8262: /* Shift Help = Compilerfehlermeldung anzeigen */
  1212.                     if(*errorstr=='\"' && errorstr[strlen(errorstr)-1]=='\"')
  1213.                     {
  1214.                         if(wp->kind & INFO)
  1215.                             wind_set(wp->wihandle,WF_INFO,errorstr);
  1216.                         else
  1217.                             form_alert(1,Aeditor[3]);
  1218.                     }
  1219.                     else
  1220.                         form_alert(1,Aeditor[4]);
  1221.                     return(TRUE);
  1222.                 case 0x027F: /* Shift DELETE */
  1223.                     if(cut)
  1224.                         free_blk(wp,(*begcut));
  1225.                     if(!wp->cstr->next && !wp->cstr->used)
  1226.                         return(TRUE); /* die letzte Zeile ist leer, beenden! */
  1227.                     undo.item=FALSE;
  1228.                     if(!(*begcut) && !(*endcut))
  1229.                     {
  1230.                         mx=wp->xwork+wp->col*wp->wscroll+1;
  1231.                         my=wp->ywork+wp->row*wp->hscroll+1;
  1232.                         if(Wdclickline(wp,begcut,endcut,mx,my))
  1233.                         {
  1234.                             graf_mouse(M_OFF,0L);
  1235.                             line=wp->cstr->next;
  1236.                             if(line)
  1237.                             {
  1238.                                Wcursor(wp);
  1239.                                 free_undoblk(wp, undo.blkbeg);
  1240.                                 cut=cut_blk(wp,(*begcut),(*endcut));
  1241.                                 undo.flag=copy_blk(wp,(*begcut),(*endcut),&undo.blkbeg,&undo.blkend);
  1242.                                 wp->col=-wp->wfirst/wp->wscroll;
  1243.                                 wp->cspos=Wshiftpage(wp,0,wp->cstr->used);
  1244.                                 /* ^Y Korrektur am Textende */
  1245.                                 if(wp->cstr != line && wp->cstr->next)
  1246.                                     wp->cstr=wp->cstr->next;
  1247.                                 Wcuron(wp);
  1248.                                 Wcursor(wp);
  1249.                                 free_blk(wp,(*begcut));
  1250.                             }
  1251.                             else /* Cursor in letzter Zeile */
  1252.                             {
  1253.                                Wcursor(wp);
  1254.                                 free_undoblk(wp, undo.blkbeg);
  1255.                                 undo.flag=copy_blk(wp,(*begcut),(*endcut),&undo.blkbeg,&undo.blkend);
  1256.                                 wp->col=-wp->wfirst/wp->wscroll;
  1257.                                 wp->cspos=Wshiftpage(wp,0,wp->cstr->used);
  1258.                                wp->cstr->used=0;
  1259.                                wp->cstr->string[0]=0;
  1260.                                refresh(wp, wp->cstr, wp->col, wp->row);
  1261.                                Wcuron(wp);
  1262.                                Wcursor(wp);
  1263.                                 hide_blk(wp,*begcut,*endcut);
  1264.                             }
  1265.                             undo.menu=WINEDIT;
  1266.                             undo.item=EDITPAST;
  1267. /*
  1268.                             graf_mouse(M_ON,0L);
  1269. */
  1270.                             return(TRUE);
  1271.                         }
  1272.                     }
  1273.                    break;
  1274.             }
  1275.             return(FALSE);
  1276.         }
  1277.         if(state & K_CTRL)
  1278.         {
  1279. /* 1.10.94 Dialog
  1280.             switch(key) /* ^F8 ist fast wie ^a, deshalb hier*/
  1281.             {
  1282.                 /* Textformatierung ^F8  = linksbündig */
  1283.                 /*                  ^F9  = zentriert   */
  1284.                 /*                  ^F10 = rechtsbündig */
  1285.                 case 0x8442: /* ^F8  */
  1286.                 case 0x8443: /* ^F9  */
  1287.                 case 0x8444: /* ^F10 */
  1288.                     textformat2(wp, begcut, endcut, key, ...);
  1289.                     return(TRUE);
  1290.                     break;
  1291.             }
  1292. */
  1293.             switch(__tolower((char)key))
  1294.             {
  1295.                case 'y':
  1296.                     if(cut)
  1297.                         free_blk(wp,(*begcut));
  1298.                     if(!wp->cstr->next && !wp->cstr->used)
  1299.                         return(TRUE); /* die letzte Zeile ist leer, beenden! */
  1300.                     undo.item=FALSE;
  1301.                     if(!(*begcut) && !(*endcut))
  1302.                     {
  1303.                         mx=wp->xwork+wp->col*wp->wscroll+1;
  1304.                         my=wp->ywork+wp->row*wp->hscroll+1;
  1305.                         if(Wdclickline(wp,begcut,endcut,mx,my))
  1306.                         {
  1307.                             graf_mouse(M_OFF,0L);
  1308.                             line=wp->cstr->next;
  1309.                             if(line)
  1310.                             {
  1311.                                Wcursor(wp);
  1312.                                 free_undoblk(wp, undo.blkbeg);
  1313.                                 cut=cut_blk(wp,(*begcut),(*endcut));
  1314.                                 undo.flag=copy_blk(wp,(*begcut),(*endcut),&undo.blkbeg,&undo.blkend);
  1315.                                 wp->col=-wp->wfirst/wp->wscroll;
  1316.                                 wp->cspos=Wshiftpage(wp,0,wp->cstr->used);
  1317.                                 /* ^Y Korrektur am Textende */
  1318.                                 if(wp->cstr != line && wp->cstr->next)
  1319.                                     wp->cstr=wp->cstr->next;
  1320.                                 Wcuron(wp);
  1321.                                 Wcursor(wp);
  1322.                                 
  1323.                                 if(clipbrd)
  1324.                                 {
  1325.                                     mevent.e_time=250;
  1326.                                    if(!(evnt_event(&mevent)&MU_KEYBD))
  1327.                                        write_clip(wp,(*begcut),(*endcut));
  1328.                                     free_blk(wp,(*begcut));
  1329.                                 }
  1330.                             }
  1331.                             else /* Cursor in letzter Zeile */
  1332.                             {
  1333.                                Wcursor(wp);
  1334.                                 free_undoblk(wp, undo.blkbeg);
  1335.                                 undo.flag=copy_blk(wp,(*begcut),(*endcut),&undo.blkbeg,&undo.blkend);
  1336.                                 wp->col=-wp->wfirst/wp->wscroll;
  1337.                                 wp->cspos=Wshiftpage(wp,0,wp->cstr->used);
  1338.                                wp->cstr->used=0;
  1339.                                wp->cstr->string[0]=0;
  1340.                                wp->w_state|=CHANGED;
  1341.                                refresh(wp, wp->cstr, wp->col, wp->row);
  1342.                                Wcuron(wp);
  1343.                                Wcursor(wp);
  1344.                                if(clipbrd)
  1345.                                {
  1346.                            mevent.e_time=250;
  1347.                                    if(!(evnt_event(&mevent)&MU_KEYBD))
  1348.                                       write_clip(wp,(*begcut),(*endcut));
  1349.                                 }
  1350.                                 hide_blk(wp,*begcut,*endcut);
  1351.                             }
  1352.                             undo.menu=WINEDIT;
  1353.                             undo.item=EDITPAST;
  1354. /*
  1355.                             graf_mouse(M_ON,0L);
  1356. */
  1357.                             return(TRUE);
  1358.                         }
  1359.                     }
  1360.                     break;
  1361.                 case 'e': /* E */
  1362.                     if(wp==*blkwp && *begcut && !(*endcut))  /* Reihenfolge NICHT vertauschen */
  1363.                     {
  1364.                         graf_mouse(M_OFF,0L);
  1365.                         Wcursor(wp);
  1366.                         *endcut=end_blk(wp,begcut,endcut);
  1367.                         Wcuroff(wp);
  1368.                         Wcursor(wp);
  1369. /*
  1370.                         graf_mouse(M_ON,0L);
  1371. */
  1372.                         if(*endcut==NULL ||                          /* Fehler? oder     */
  1373.                           ((*begcut)->begcol == (*begcut)->endcol)) /* gleiche Stelle? */
  1374.                         {
  1375.                             hide_blk(wp,*begcut,*endcut);
  1376.                             *blkwp=NULL;
  1377.                         }
  1378.                         return(TRUE);
  1379.                     }
  1380.                     break;
  1381.             case 'a': /* A bei SysKey */
  1382.                 case 'b': /* B */
  1383.                     if(!cut)                                 /* gibt es erst noch müll zu löschen */
  1384.                         hide_blk(wp,*begcut,*endcut);
  1385.                     else
  1386.                         free_blk(wp,*begcut);
  1387.                     if(!(*begcut) && !(*endcut))
  1388.                     {
  1389.                         *begcut=beg_blk(wp,*begcut,*endcut);
  1390.                         *endcut=NULL;
  1391.                         cut=FALSE;
  1392.                         *blkwp=wp;                             /* diesem Fenster gehört der Block */
  1393.                         return(TRUE);
  1394.                     }
  1395.                     break;
  1396.                 case '9': /* Durchfallen und exitcode immer erhöhen */
  1397.                     exitcode++;
  1398.                 case '8':
  1399.                     exitcode++;
  1400.                 case '7': 
  1401.                     exitcode++;
  1402.                 case '6':
  1403.                     exitcode++;
  1404.                 case '5':
  1405.                     exitcode++;
  1406.                 case '4':
  1407.                     exitcode++;
  1408.                 case '3':
  1409.                     exitcode++;
  1410.                 case '2':
  1411.                     exitcode++;
  1412.                 case '1':
  1413.                     exitcode++;
  1414.                 case '0': /* CTRL-Ziffernblock = Exitcode */
  1415.                     if(exitcode)
  1416.                     {
  1417.                   graf_mouse(M_ON, NULL);/* nur bei eventgesteuerter Maus */
  1418. /*
  1419.                        if(wp->w_state & CHANGED)
  1420.                        {
  1421.                             if(!strcmp((char *)Wname(wp),NAMENLOS))
  1422.                                 write_file(wp,TRUE);
  1423.                             else
  1424.                              write_file(wp,FALSE);
  1425.                      }
  1426.                        for(i=1;i<MAXWINDOWS;i++)
  1427.                           _wind[i].w_state &= ~CHANGED;
  1428. */
  1429. /* alles sichern MT 18.6.95 */
  1430.                        for(i=1;i<MAXWINDOWS;i++)
  1431.                           if(_wind[i].w_state & CHANGED)
  1432.                           {
  1433.                                 if(!strcmp((char *)Wname(wp),NAMENLOS))
  1434.                                     write_file(wp,TRUE);
  1435.                                 else
  1436.                                  write_file(wp,FALSE);
  1437.                               _wind[i].w_state &= ~CHANGED;
  1438.                           }
  1439.                        exit(exitcode);
  1440.                     }
  1441.                     break;
  1442.             }
  1443.             switch(key)
  1444.             {
  1445.             case 0x8452: /* ^Insert */
  1446.                return(TRUE);
  1447.             case 0x8461: /* ^Undo */
  1448.                return(TRUE);
  1449.             case 0x8462: /* ^Help */
  1450.                return(TRUE);
  1451.                 case 0x0408: /* ^BACKSPACE */
  1452.                     if(cut)
  1453.                         free_blk(wp,(*begcut));
  1454.                     if(!(*begcut) && !(*endcut))
  1455.                     {
  1456.                         wp->w_state|=CHANGED; /* es wurde editiert */
  1457.                         lastwstr=wp->wstr;
  1458.                         lasthfirst=wp->hfirst;
  1459.                         begline=wp->row+wp->hfirst/wp->hscroll;
  1460.                         endline=begline;
  1461.                         *begcut=*endcut=wp->cstr;
  1462.                         (*begcut)->endcol=(*endcut)->endcol=wp->col+wp->wfirst/wp->wscroll;
  1463.                         for(wordend=(*begcut)->endcol; wordend>0; wordend--)
  1464.                             if((*begcut)->string[wordend]==' ')
  1465.                                 break;
  1466.                         for(wordend; wordend>0; wordend--)
  1467.                             if((*begcut)->string[wordend-1]!=' ')
  1468.                                 break;
  1469.                         (*begcut)->begcol=(*endcut)->begcol=wordend;
  1470.                         (*begcut)->attr  =((*endcut)->attr|=SELECTED);
  1471.  
  1472.                         if((*begcut)->begcol==0 && (*begcut)->endcol==wp->cstr->used)
  1473.                             endline++; /* Rest der Zeile */
  1474.  
  1475.                         graf_mouse(M_OFF,0L);
  1476.                         Wcursor(wp);
  1477. /*GEMDOS*/            mark_line(wp,wp->cstr,wp->row);
  1478.                         evnt_timer(25,0);
  1479.                         cut=cut_blk(wp,(*begcut),(*endcut));
  1480.                         free_undoblk(wp, undo.blkbeg);
  1481.                         undo.flag=copy_blk(wp,(*begcut),(*endcut),&undo.blkbeg,&undo.blkend);
  1482.                         Wcuron(wp);
  1483.                         Wcursor(wp);
  1484. /*
  1485.                         graf_mouse(M_ON,0L);
  1486. */
  1487.                         undo.menu=WINEDIT;
  1488.                         undo.item=EDITPAST;
  1489.                         return(TRUE);
  1490.                     }
  1491.                     break;
  1492.                 case 0x047F: /* ^DELETE */
  1493.                     if(cut)
  1494.                         free_blk(wp,(*begcut));
  1495.                     if(!(*begcut) && !(*endcut))
  1496.                     {
  1497.                         wp->w_state|=CHANGED; /* es wurde editiert */
  1498.                         lastwstr=wp->wstr;
  1499.                         lasthfirst=wp->hfirst;
  1500.                         begline=wp->row+wp->hfirst/wp->hscroll;
  1501.                         endline=begline;
  1502.                         *begcut=*endcut=wp->cstr;
  1503.                         (*begcut)->begcol=(*endcut)->begcol=wp->col+wp->wfirst/wp->wscroll;
  1504.                         for(wordend=(*begcut)->begcol; wordend<wp->cstr->used; wordend++)
  1505.                             if((*begcut)->string[wordend]==' ')
  1506.                                 break;
  1507.                         for(wordend; wordend<wp->cstr->used; wordend++)
  1508.                             if((*begcut)->string[wordend]!=' ')
  1509.                                 break;
  1510.                         (*begcut)->endcol=(*endcut)->endcol=wordend;
  1511.                         (*begcut)->attr  =((*endcut)->attr|=SELECTED);
  1512.  
  1513.                         if((*begcut)->begcol==0 && (*begcut)->endcol==wp->cstr->used)
  1514.                             endline++; /* Rest der Zeile */
  1515.  
  1516.                         graf_mouse(M_OFF,0L);
  1517.                         Wcursor(wp);
  1518. /*GEMDOS*/            mark_line(wp,wp->cstr,wp->row);
  1519.                         evnt_timer(25,0);
  1520.                         cut=cut_blk(wp,(*begcut),(*endcut));
  1521.                         free_undoblk(wp, undo.blkbeg);
  1522.                         undo.flag=copy_blk(wp,(*begcut),(*endcut),&undo.blkbeg,&undo.blkend);
  1523.                         Wcuron(wp);
  1524.                         Wcursor(wp);
  1525. /*
  1526.                         graf_mouse(M_ON,0L);
  1527. */
  1528.                         undo.menu=WINEDIT;
  1529.                         undo.item=EDITPAST;
  1530.                         return(TRUE);
  1531.                     }
  1532.                     break;
  1533.             }
  1534.             return(FALSE);
  1535.         }
  1536.         if(state & K_ALT)
  1537.         {
  1538.             switch(__tolower((char)key))
  1539.             {
  1540.                 case '1':                /* Textmarken anspringen */
  1541.                 case '2':
  1542.                 case '3':
  1543.                 case '4':
  1544.                 case '5':
  1545.                     if(state & (K_LSHIFT|K_RSHIFT))
  1546.                     {
  1547.                         textmarker(wp,markmenu,0,state,(char)key-'1');
  1548.                         return(TRUE);
  1549.                     }
  1550.                     break;
  1551.                 case '~': /* ALT~ = linetoggle */
  1552.                    if(wp->cstr->next)
  1553.                    {
  1554.                         wp->w_state        |= CHANGED; /* es wurde editiert */
  1555.                         used                 = wp->cstr->next->used;
  1556.                         len                 = wp->cstr->next->len;
  1557.                         cp                     = wp->cstr->next->string;
  1558.                         wp->cstr->next->string = wp->cstr->string,
  1559.                         wp->cstr->next->used      = wp->cstr->used;
  1560.                         wp->cstr->next->len      = wp->cstr->len;
  1561.                         wp->cstr->used    = used;
  1562.                         wp->cstr->len     = len;
  1563.                         wp->cstr->string = cp;
  1564.                         graf_mouse(M_OFF,0L);
  1565.                         Wcursor(wp);
  1566.                         refresh(wp,wp->cstr,          0,wp->row  );
  1567.                         refresh(wp,wp->cstr->next,0,wp->row+1);
  1568.                         Wcursor(wp);
  1569. /*
  1570.                         graf_mouse(M_ON,0L);
  1571. */
  1572.                         undo.item=FALSE;
  1573.                         return(TRUE);
  1574.                     }
  1575.                     break;
  1576.             }
  1577.             switch(key)
  1578.             {
  1579. /* 2.10.94
  1580.                 /* Texteffekte */
  1581.                 case 0x883E: /* ALT-F4 */
  1582.                 case 0x883F: /* ALT-F5 */
  1583.                 case 0x8840: /* ALT-F6 */
  1584.                     switch(key)
  1585.                     {
  1586.                         case 0x883E: /* ALT-F4 */
  1587.                             wp->cstr->effect  = TXT_NORMAL;
  1588.                             break;
  1589.                         case 0x883F: /* ALT-F5 */
  1590.                             wp->cstr->effect ^= TXT_THICKENED;
  1591.                             break;
  1592.                         case 0x8840: /* ALT-F6 */
  1593.                             wp->cstr->effect ^= TXT_SKEWED;
  1594.                             break;
  1595.                     }
  1596.                     graf_mouse(M_OFF,0L);
  1597.                     Wcursor(wp);
  1598.                     rect.g_x=wp->xwork;
  1599.                     rect.g_y=wp->ywork + wp->row * wp->hscroll;
  1600.                     rect.g_w=wp->wwork;
  1601.                     rect.g_h=wp->hscroll;
  1602.                     Wredraw(wp,&rect);
  1603.                   Wcuron(wp);
  1604.                     Wcursor(wp);
  1605. /*
  1606.                     graf_mouse(M_ON,0L);
  1607. */
  1608.                     return(TRUE);                
  1609. */
  1610.             case 0x8861: /* ALT-UNDO */
  1611.                return(TRUE);
  1612.                 case 0x087F: /* ALT-DELETE, bis zum Ende der Zeile löschen */
  1613.                     if(cut)
  1614.                         free_blk(wp,(*begcut));
  1615.                     if(!(*begcut) && !(*endcut))
  1616.                     {
  1617.                         wp->w_state|=CHANGED; /* es wurde editiert */
  1618.                         lastwstr=wp->wstr;
  1619.                         lasthfirst=wp->hfirst;
  1620.                         begline=wp->row+wp->hfirst/wp->hscroll;
  1621.                         endline=begline;
  1622.                         *begcut=*endcut=wp->cstr;
  1623.                         (*begcut)->begcol=(*endcut)->begcol=wp->col+wp->wfirst/wp->wscroll;
  1624.                         (*begcut)->endcol=(*endcut)->endcol=wp->cstr->used;
  1625.                         (*begcut)->attr  =((*endcut)->attr|=SELECTED);
  1626.                         if((*begcut)->begcol == 0) /* ganze Zeile */
  1627.                             endline++;
  1628.                         graf_mouse(M_OFF,0L);
  1629.                         Wcursor(wp);
  1630. /*GEMDOS*/            mark_line(wp,wp->cstr,wp->row);
  1631.                         evnt_timer(25,0);
  1632.                         cut=cut_blk(wp,(*begcut),(*endcut));
  1633.                         free_undoblk(wp, undo.blkbeg);
  1634.                         undo.flag=copy_blk(wp,(*begcut),(*endcut),&undo.blkbeg,&undo.blkend);
  1635.                         Wcuron(wp);
  1636.                         Wcursor(wp);
  1637. /*
  1638.                         graf_mouse(M_ON,0L);
  1639. */
  1640.                         undo.menu=WINEDIT;
  1641.                         undo.item=EDITPAST;
  1642.                         return(TRUE);
  1643.                     }
  1644.                     break;
  1645.             }
  1646.             return(FALSE);
  1647.         }
  1648.     }
  1649.     else
  1650.     {
  1651.         if(!state)
  1652.         {
  1653.             switch(key)
  1654.             {
  1655.                 case 0x8062: /* Help */
  1656.                     if(!help())
  1657.                         form_alert(1,Aeditor[2]);
  1658.                     return(TRUE);
  1659.                 case 0x8061: /* UNDO */
  1660.                     desel_icons(desktop,DESKICN1,DESKICNC,TRUE);
  1661.                     return(TRUE);
  1662.             }
  1663.             return(FALSE);
  1664.         }
  1665.         if(state & K_CTRL)
  1666.         {
  1667.            switch(__tolower((char)key))
  1668.            {
  1669.                 case '9': /* Durchfallen und exitcode immer erhöhen */
  1670.                     exitcode++;
  1671.                 case '8':
  1672.                     exitcode++;
  1673.                 case '7': 
  1674.                     exitcode++;
  1675.                 case '6':
  1676.                     exitcode++;
  1677.                 case '5':
  1678.                     exitcode++;
  1679.                 case '4':
  1680.                     exitcode++;
  1681.                 case '3':
  1682.                     exitcode++;
  1683.                 case '2':
  1684.                     exitcode++;
  1685.                 case '1':
  1686.                     exitcode++;
  1687.                 case '0': /* CTRL-Ziffernblock = Exitcode */
  1688.                     if(exitcode)
  1689.                     {
  1690. /*
  1691.                   graf_mouse(M_ON, NULL);/* nur bei eventgesteuerter Maus */
  1692.                        if(wp->w_state & CHANGED)
  1693.                        {
  1694.                             if(!strcmp((char *)Wname(wp),NAMENLOS))
  1695.                                 write_file(wp,TRUE);
  1696.                             else
  1697.                              write_file(wp,FALSE);
  1698.                      }
  1699.                        for(i=1;i<MAXWINDOWS;i++)
  1700.                           _wind[i].w_state &= ~CHANGED;
  1701.                        exit(exitcode);
  1702. */
  1703.                     }
  1704.                     break;
  1705.             }
  1706.             return(FALSE);
  1707.         }
  1708.         if(state & K_ALT)
  1709.         {
  1710.             return(FALSE);
  1711.         }
  1712.     }
  1713.     return(FALSE);
  1714. }
  1715.